package com.season.seasonStudy.javase.j_003_array_collection;

import com.season.seasonStudy.javase.entity.Users;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

/**
 * 数组:
 * 		类型固定,长度固定,连续开辟的空间
 * 集合:	util包
 * 		Object 类型不固定
 * 		存储大量数据
 * 数组若想类型不固定,那就用父类Object,取出来在向下转型(向上向下转型,多态)
 * 					--------因为虽然借用了父类名字(引用),但是在堆里还是子类
 * 
 * Collection 值存储   只存值
 * 			不唯一 无序
 * 		List 有序	 线性 不唯一	(位置)
 * 			ArrayList	动态数组---随机访问效率高		跟list集合差不多,几乎没拓展	所以一般进行多态声明
 * 			LinkedList	链表结构---添加删除效率高	
 * 		Set 无序 散列	唯一
 * 			HashSet
 * 		Map	Key--Value	键值存储  就像地图一样,有坐标位置
 * 	  	 	Set--Collection
 *			HashMap
 * 
 * 操作方法:		通用的写在顶级接口上	特殊的写在子接口的上面		
 * 		
 * 	添加(存)	add(Object)
 * 	获取(拿)	Object[] obj =toArray()
 * 	查找		containts(Object)只是告诉是否有这个
 * 	删除		remove(Object)
 * 	修改		
 * 	长度		size()
 * 	是否空 	isEmpty()					
 * 	遍历	
 * 
 * 对于对象,是地址赋值,所以值改变了,对象都变了
 * 
 * 		想要有下标就是List
 *			List coll = new ArrayList();
 * 			coll.add(1,obj)
 * 			collection coll = new ArrayList();
 * 			coll.add(1,obj);这就会报错,因为collection没顺序
 * 
 * 循环遍历
 * 
 */
	
public class CollectionDemo {
	public static void main(String[] args) {
		Collection coll = new ArrayList();

		Set set = new HashSet();
		// 跟collection差不多
		LinkedList ll = new LinkedList();// 也有按下标找,但是性能能差, 多了addLast addFirst
		// 还多了好多, 是因为还继承了好多其他的接口
		set.add("asdsad");
		set.add(123);
		set.add('a');
		for (Object object : set) {
			System.out.println(object);
		}
	}
	
	public static void main5(String[] args) {
		Map map=new HashMap();
		map.put("1", new Users(1,"abc1",34));
		map.put("2", new Users(2,"abc12",24));
		map.put("3", new Users(3,"abc13",43));
		map.put("4", new Users(1,"abc1",75));
		System.out.println(map.size());
		Users us=(Users)map.get("4");
		System.out.println(us);
		map.remove("4");
		System.out.println(map.size());
		Set keys=map.keySet();
		for (Object object : keys) {
			System.out.println("key:"+object);
		}
		Collection values=map.values();
		for (Object object : values) {
			System.out.println("value:"+object);
		}
		Set kvs=map.entrySet();
		for (Object object : kvs) {
			Entry entry=(Entry)object;
			System.out.println("key:"+entry.getKey()+
					",value："+entry.getValue());
		}
	}
	public static void main3(String[] args) {
		Set set=new HashSet();
		set.add(new Users(1,"abc1",56));
		set.add(new Users(2,"abc2",24));
		set.add(new Users(3,"abc3",55));
		set.add(new Users(1,"abc1",62));
		System.out.println(set.size());
		for (Object object : set) {
			Users us=(Users)object;
			System.out.println(us);
		}
		
	}
	public static void main2(String[] args) {
		Collection al=new LinkedList();
		al.add(new Users(1,"abc1",42));
		al.add(new Users(2,"abc2",63));
		al.add(new Users(3,"abc3",62));
		System.out.println(al.size());
		//遍历增强for 循环 foreach
		/*for (Object object : al) {
			Users us=(Users)object;
			System.out.println(us);
		}*/
		//使用迭代器iterator遍历集合
		Iterator it=al.iterator();
		while(it.hasNext()){
			Users user=(Users)it.next();
			System.out.println(user);
		}
		/*while(!al.isEmpty()) {
			//随机访问
				Users us=(Users)al.removeFirst();
				System.out.println(us);
		}*/
		System.out.println(al.size());
	}
	public static void main1(String[] args) {
		Users u=new Users(3,"ghi",51);
		List al=new ArrayList();
		al.add(new Users(1,"abc",15));
		al.add(new Users(2,"def",63));
		al.add(0,new Users(3,"ghi",26));
		System.out.println("长度："+al.size());
		//遍历
		for (int i = 0; i < al.size(); i++) {
							//随机访问
			Users us=(Users)al.get(i);
			System.out.println(us);
		}
		//是否存在（比较实用的是对象的equals方法）
		System.out.println(al.contains(u));
			al.remove(u);
		System.out.println("长度："+al.size());
	}

}
